/**
 * - 方法集
 */
const Util = {
	
    /**
     * 将身份证号隐藏，只展示前两位和最后一位
     * @param {string} idCard - 身份证号
     * @returns {string} - 隐藏后的身份证号
     */
    hideIdCard(idCard) {
        // 检查输入是否为字符串，以及长度是否小于3
        if (typeof idCard !== 'string' || idCard.length < 3) {
            return idCard; // 如果不满足要求，则直接返回原始值
        }
        const firstTwoDigits = idCard.slice(0, 2);
        const lastDigit = idCard.slice(-1);
        const hiddenDigits = '*'.repeat(idCard.length - 3);
        return firstTwoDigits + hiddenDigits + lastDigit;
    },
    /**
     * 将毫秒转换为小时和分钟
     * @param {number} milliseconds - 表示毫秒数的参数
     * @returns {string} - 转换后的小时和分钟的字符串表示
     */
    convertMillisecondsToTime(milliseconds) {
        let hours = Math.floor(milliseconds / (1000 * 60 * 60));
        let minutes = Math.floor((milliseconds % (1000 * 60 * 60)) / (1000 * 60));
        if (hours === 0) {
            return `${minutes}分`;
        }
        return `${hours}时${minutes}分`;
    },
    /**
     * 使用正则表达式替换特殊字符
     * @param str {string} 特殊字符转串
     * @return {string}  普通字符串
     */
    escapeSpecialCharacters(str) {
        return str.replace(/\\/g, "")
            .replace(/\n/g, "")
            .replace(/\r/g, "")
            .replace(/\t/g, "")
            .replace(/'/g, "")
            .replace(/"/g, "");
    },
    /**
     * 深拷贝
     * @param obj 要被拷贝的对象
     * @return {JSON} 深拷贝的对象
     */
    deepCopy(obj) {
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }
        let temp = obj.constructor(); // 给出了正确的原型
        for (let key in obj) {
            if (obj.hasOwnProperty(key)) {
                temp[key] = this.deepCopy(obj[key]); // 使用 this.deepCopy 进行递归调用
            }
        }
        return temp;
    },
    /**
     * 格式化数字，将大数字转换为带有单位的字符串
     * @param {number} num - 需要格式化的整数
     * @returns {string} - 格式化后的字符串
     */
    formatNumber(num) {
        if (num >= 1000 && num < 10000) {
            return (num / 1000).toFixed(2) + 'k';
        } else if (num >= 10000) {
            return (num / 10000).toFixed(2) + 'w';
        } else {
            return num.toFixed(2);
        }
    },
    /**
     * 将字符串缩短为50长度，超过50的部分用...省略
     * @param {string} str - 要缩短的字符串
     * @param {string} num - 截取长度
     * @returns {string} - 缩短后的字符串
     */
    shortenString(str, num) {
        if (str.length <= num) {
            return str; // 字符串长度小于等于50，直接返回原始字符串
        } else {
            return str.substring(0, num) + '...'; // 字符串长度大于50，截取前50个字符并加上省略号
        }
    },

    /**
     * 格式化手机号，前三位加空格，中间四位加空格
     * @param {string} phoneNumber - 手机号
     * @returns {string} 格式化后的手机号
     */
    formatPhoneNumber(phoneNumber) {
        if (!phoneNumber) {
            return ''; // 如果手机号为空，直接返回空字符串
        }
        // 去除空格和横杠
        phoneNumber = phoneNumber.replace(/\s/g, '').replace(/-/g, '');
        // 格式化手机号
        let formattedPhoneNumber = '';
        for (let i = 0; i < phoneNumber.length; i++) {
            if (i === 3 || i === 7) {
                formattedPhoneNumber += ' ';
            }
            formattedPhoneNumber += phoneNumber.charAt(i);
        }
        return formattedPhoneNumber;
    },
    /**
     * 格式化银行卡卡号，每4位数后加一个空格
     * @param {string} cardNumber - 银行卡卡号
     * @returns {string} 格式化后的银行卡卡号
     */
    formatBankCardNumber(cardNumber) {
        if (!cardNumber) {
            return ''; // 如果银行卡号为空，直接返回空字符串
        }
        // 去除空格和横杠
        cardNumber = cardNumber.replace(/\s/g, '').replace(/-/g, '');
        // 每4位数后加一个空格
        let formattedCardNumber = '';
        for (let i = 0; i < cardNumber.length; i++) {
            if (i > 0 && i % 4 === 0) {
                formattedCardNumber += ' ';
            }
            formattedCardNumber += cardNumber.charAt(i);
        }
        return formattedCardNumber;
    },
    /**
     * - 将时间戳、拼接成年-月-日 时:分:秒格式字符串
     * @param {Number} timestamp 时间戳 */
    formatTimestamp(timestamp) {
        const date = new Date(timestamp);
        // 获取年、月、日、时、分、秒
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        const hours = String(date.getHours()).padStart(2, '0');
        const minutes = String(date.getMinutes()).padStart(2, '0');
        const seconds = String(date.getSeconds()).padStart(2, '0');
        // 拼接成年-月-日 时:分:秒格式字符串
        const formattedTime = `${year}-${month}-${day} ${hours}:${minutes}`;
        return formattedTime;
    },

    /*** - 将时间戳、转换成 时分 格式字符串
     * @param {Number} timestamp 时间戳 */
    ConversionTimeDivision(timestamp) {
        const date = new Date(timestamp);
        // 获取 时、分
        const hours = String(date.getHours()).padStart(2, '0');
        const minutes = String(date.getMinutes()).padStart(2, '0');
        // 拼接成年-月-日 时:分:秒格式字符串
        const formattedTime = `${hours}${minutes}`;
        return formattedTime;
    },
    /**
     * - 隐藏手机号中间的四位数字
     * @param {Number}phoneNumber 手机号
     */
    hidePhoneNumber(phoneNumber) {
        if (phoneNumber.length === 11) {
            const hiddenPart = phoneNumber.slice(3, 7).replace(/\d/g, '*');
            return phoneNumber.slice(0, 3) + hiddenPart + phoneNumber.slice(7);
        }
        return phoneNumber;
    },
    /**
     * 获取当天开始的时间戳和当天结束的时间戳
     * @param {number} offset 偏移量，表示从当天向前或向后的天数
     * @returns {object} 包含开始时间戳和结束时间戳的对象
     */
    getDayTimestamps(offset) {
        const currentDate = new Date();
        const targetDate = new Date(currentDate);
        // 根据偏移量计算目标日期
        targetDate.setDate(currentDate.getDate() - offset);
        // 设置目标日期的时间为凌晨 00:00:00.000
        targetDate.setHours(0, 0, 0, 0);
        const startTime = targetDate.getTime();
        // 设置目标日期的时间为当天的最后一刻 23:59:59.999
        targetDate.setHours(23, 59, 59, 999);
        const endTime = targetDate.getTime();
        return {
            startTime,
            endTime
        };
    },


    /**
     * 隐藏手机号码中间的部分数字
     * @param {string} phoneNumber - 需要隐藏的手机号码
     * @returns {string} - 隐藏中间部分数字后的手机号码
     */
    hidePhoneNumber(phoneNumber) {
        if (phoneNumber.length === 11) {
            const hiddenPart = phoneNumber.slice(3, 7).replace(/\d/g, "*");
            return phoneNumber.slice(0, 3) + hiddenPart + phoneNumber.slice(7);
        }
        return phoneNumber;
    },
    /**
     * 生成订单号函数
     * 使用当前日期和随机数生成唯一的订单号
     * @returns {string} 订单号
     */
    setOutTradeNo(letter) {
        const date = new Date(); // 当前日期
        const outTradeNo = letter + date.getFullYear() + '' + (date.getMonth() + 1) + '' + date.getDate() + '' +
            date.getHours() + '' + date.getMinutes() + '' + date.getSeconds(); // 根据当前日期生成订单号的前缀部分
        const random = Math.round(Math.random() * 100) + '' + Math.round(Math.random() * 100) + '' + Math.round(
            Math.random() * 100); // 生成随机数部分
        return outTradeNo + '' + random; // 返回完整的订单号
    },
    /**
     * 格式化日期为 "yyyy-mm-dd" 的形式
     * @param {Date} date - 要格式化的日期对象
     * @returns {string} 格式化后的日期字符串
     */
    formatDate(date) {
        var year = date.getFullYear();
        var month = date.getMonth() + 1;
        var day = date.getDate();

        // 格式化日期为 "yyyy-mm-dd" 的形式
        return (month < 10 ? '0' + month : month) + '/' + (day < 10 ? '0' + day : day);
    },
    /**
     *    根据订单状态改变字体颜色
     *@param {Number} Num 整数1、2、3····  */
    onStatus(Num) {
        switch (Num) {
            case 0:
                return "#73629d"
                break;
            case 1:
                return "#e17055"
                break;
            case 2:
                return "#4cd964"
                break;
            case 3:
                return "#f0ad4e"
                break;
            case 4:
                return "#f0ad4e"
                break;
            case 5:
                return "#4cd964"
                break;
            case 6:
                return "#00da74"
                break;
            case 7:
                return "#999"
                break;
            case 8:
                return "#999"
                break;
            case 9:
                return "#999"
                break;
            default:
                return "#808080"
                break;
        }
    },
    /**
     * 封装方法，计算两个值之间的百分比
     *
     * @param {number} value1 - 第一个值
     * @param {number} value2 - 第二个值
     * @returns {string} - 百分比字符串整数
     */
    calculatePercentage(value1, value2) {
        let percentage = (value1 / (value1 + value2)) * 100; // 计算百分比

        // 确保百分比在 0 到 100 之间
        percentage = Math.min(100, Math.max(0, percentage));

        return percentage.toFixed(2); // 返回百分比字符串整数
    }
};

export default Util;